home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / m68k / 68343ffp.arc / FFPCALC.SA < prev    next >
Text File  |  1989-08-30  |  23KB  |  568 lines
  1.          TTL       FAST FLOATING POINT - DESK CALCULATOR DRIVER
  2. ***************************************
  3. * (C) COPYRIGHT 1980 BY MOTOROLA INC. *
  4. ***************************************
  5.  
  6. ******************************************
  7. * THIS IS A DESK-CALCULATOR DIAGNOSTIC   *
  8. * PROGRAM FOR THE MC68344 ROM FAST FLOAT-*
  9. * ING POINT SUBROUTINES. THE INPUT       *
  10. * FORMAT IS NORMAL FORTRAN EXPRESSION    *
  11. * SYNTAX WITH AN OPTIONAL ASSIGNMENT     *
  12. * STATEMENT FOR THE ONLY VARIABLES "X"   *
  13. * AND "Y".  THE VARIABLES CAN BE USED IN *
  14. * EXPRESSIONS.  NO BLANKS ALLOWED.       *
  15. *                                        *
  16. * A FLOATING POINT VALUE MAY BE ENTIRELY *
  17. * SPECIFIED IN HEXADECIMAL.  THIS IS DONE*
  18. * BY FOLLOWING A $ WITH EIGHT HEX DIGITS.*
  19. *                                        *
  20. * A SPECIAL DIADIC OPERATOR "?" PERFORMS *
  21. * A COMPARISON BETWEEN TWO VALUES REPORT-*
  22. * ING ALL VALID BRANCH CONDITIONS.       *
  23. *                                        *
  24. * FUNCTION 'TST( )' RETURNS A CCR RESULT *
  25. * FOR PLUS, MINUS, NAN AND ZERO.         *
  26. *                                        *
  27. * FUNCTION 'NEG( )' OPERATES EXACTLY LIKE*
  28. * THE PREFIX MINUS SIGN.                 *
  29. *                                        *
  30. * ROUNDING (POWER OF TEN) IS SET WITH    *
  31. * AN "R=VALUE" STATEMENT (DEFAULT -100). *
  32. * FOR EXAMPLE, R=-1 ROUNDS TENTHS TO     *
  33. * UNITS.                                 *
  34. *                                        *
  35. *   EXAMPLES:      X=32.5                *
  36. *                                        *
  37. *                  SQRT(5)*2             *
  38. *                                        *
  39. *                  X                     *
  40. *                                        *
  41. *                  Y=ABS(X)**.2+3.4      *
  42. *                                        *
  43. *                  10E-4*COS(Y-SIN(X))   *
  44. *                                        *
  45. *                  X=10E10+Y             *
  46. *                                        *
  47. *                  $7F80012F+ATAN(2)     *
  48. *                                        *
  49. *                  3.1?X                 *
  50. *                                        *
  51. *   FUNCTIONS AVAILABLE:  SQRT LOG EXP   *
  52. *      SIN COS TAN ATAN SINH COSH TANH   *
  53. *      POWER (VIA ** OPERATOR) ABS NEG   *
  54. *      INT (CONVERT TO INTEGER)          *
  55. *                                        *
  56. ******************************************
  57.          PAGE
  58.          OPT       FRS
  59.  
  60.          XREF      FFPAFP,FFPFPA,FFPSQRT,FFPARND,FFPFPI,FFPIFP SUBROUTINES
  61.          XREF      FFPADD,FFPSUB,FFPDIV,FFPMUL,FFPCMP,FFPTST,FFPABS,FFPNEG
  62.          XREF      FFPSIN,FFPCOS,FFPTAN,FFPEXP,FFPLOG,FFPPWR,FFPATAN
  63.          XREF      FFPSINH,FFPCOSH,FFPTANH
  64.  
  65.          XDEF      FFPCALC
  66.  
  67.          SECTION   2
  68.  
  69. ******************************************
  70. * FAST FLOATING POINT     CALCULATOR     *
  71. *      VERSION 1.1    4/10/81            *
  72. ******************************************
  73.  
  74. *
  75. * AT LABEL 'INPUT' THE STACK POINTS TO THE INPUT BUFFER
  76. *
  77. * DURING CALCULATIONS A6 HOLDS THE ABOVE VALUE FOR ERROR ABORTS
  78. *
  79.  
  80. FFPCALC  LEA       STACK,SP  LOAD STACK
  81.  
  82.          BSR       MSG                 PUT BLANK LINE BEFORE HEADING
  83.          DC.L      '        '          BLANK LINE
  84.          LEA       STARTM,A0         SEND STARTUP MESSAGE
  85.          LEA       STARTME,A1        MESSAGE END
  86.          BSR       PUT                 CALL PUT SUBROUTINE
  87.          LEA       STARTM2,A0         SEND STARTUP MESSAGE
  88.          LEA       STARTM2E,A1        MESSAGE END
  89.          BSR       PUT                 CALL PUT SUBROUTINE
  90.          BSR       MSG       BLANK LINE AFTER HEADING
  91.          DC.L      '        '          BLANK LINE
  92.  
  93.          LEA       -80(SP),SP ALLOCATE BUFFER
  94.          MOVE.L    SP,A6     SETUP ERROR RECOVERY FRAME POINTER
  95.  
  96.          MOVE.L    #26,D0    SETUP EXCEPTION VECTORS
  97.          LEA       EXCTBL,A0 TABLE ADDRESS
  98.          TRAP      #1        TAKE EXCEPTIONS FOR ZERO DIVIDE AND OVERFLOW
  99.          BEQ.S     INPUT
  100.          TRAP      #15       ERROR IF SOMETHING WRONG
  101.  
  102. INPUT    BSR       MSG       ISSUE PROMPT
  103.          DC.L      'READY'
  104.          MOVE.L    SP,A0     SETUP START ADDR
  105.          LEA       79(SP),A1 AND ENDING
  106.          BSR       GET       READ A LINE OF INPUT
  107.          CLR.B     OVFSET    CLEAR OVERFLOW STATUS
  108.          CLR.B     ZDVSET    CLEAR ZERO DIVIDE STATUS
  109.          MOVE.W    (SP),D0   GET FIRST TWO BYTES
  110. * TEST FOR 'QUIT' COMMAND
  111.          CMP.B     #'Q',(SP) ? "Q" COMMAND FOR QUIT
  112.          BEQ       QUIT
  113. * TEST FOR 'X=' ASSIGNMENT
  114.          LEA       2(SP),A0  DEFAULT ASSIGNMENT SCAN POSITION
  115.          CMP.W     #'X=',D0  ? ASSIGNMENT
  116.          BNE.S     NOTXASG   BRANCH IF NOT
  117.          BSR       INTRP     INTERPRET THE EXPRESSION
  118.          MOVE.L    D7,X      SAVE IN X
  119.          BRA.S     CALPRNT   PRINT OUT ITS VALUE
  120. * TEST FOR 'Y=' ASSIGNMENT
  121. NOTXASG  CMP.W     #'Y=',D0  ? Y ASSIGNMENT
  122.          BNE.S     NOTASG    BR NOT ASSIGNMENT
  123.          BSR       INTRP     INTERPRET THE EXPRESSION
  124.          MOVE.L    D7,Y      SAVE IN Y
  125.          BRA.S     CALPRNT    PRINT OUT ITS VALUE
  126. * TEST FOR 'R=' ROUNDING ASSIGNMENT
  127. NOTASG   CMP.W     #'R=',D0  ? ROUND SET
  128.          BNE.S     NOTRND    BRANCH NOT
  129.          BSR       INTRP     INTERPRET EXPRESSION
  130.          MOVE.L    D7,D1     SAVE FLOAT VALUE
  131.          BSR       FFPFPI    TO INTEGER
  132.          MOVE.L    D7,ROUND  SAVE ROUNDING FACTOR
  133.          MOVE.L    D1,D7     RESTORE FLOAT VALUE
  134.          BRA.S     CALPRNT   AND PRINT IT OUT
  135. NOTRND   LEA       (SP),A0   START SCAN AT FRONT
  136.          BSR       INTRP     INTERPRET EXPRESSION
  137.          BRA.S     CALPRNT   AND PRINT IT OUT
  138.  
  139. * DISPLAY RESULT BACK IN ASCII
  140. HEXTBL   DC.L      '0123456789ABCDEF'
  141.  
  142. CALPRNT  TST.B     OVFSET    ? OVERFLOW DETECTED
  143.          BEQ.S     CALNOV    BRANCH IF NOT
  144.          BSR       MSG       GIVE OVERFLOW INDICATOR
  145.          DC.L      'OVERFLOW'  EYE-CATCHER
  146. CALNOV   TST.B     ZDVSET    ? ZERO DIVIDE DETECTED
  147.          BEQ.S     CALNOZ    BRANCH IF NOT
  148.          BSR       MSG       SHOW ZERO DIVIDE FOUND
  149.          DC.L      'ZERO DIV'
  150. CALNOZ   LEA       -8(SP),SP SETUP HEX TRANSLATE AREA
  151.          MOVE.L    #7,D0     LOOP 8 TIMES
  152.          MOVE.L    D7,D6     COPY FLOATING VALUE
  153. TOHEX    MOVE.B    D6,D1     TO NEXT FOUR BITS
  154.          AND.W     #%1111,D1 STRIP REST
  155.          MOVE.B    HEXTBL(D1),0(SP,D0) CONVERT TO HEX
  156.          LSR.L     #4,D6     TO NEXT HEX DIGIT
  157.          DBRA      D0,TOHEX  LOOP UNTIL DONE
  158.          MOVE.W    #'  ',-(SP) BLANK SEPERATOR
  159.          BSR       FFPFPA    BACK TO ASCII
  160.          MOVE.L    ROUND,D6  SETUP ROUNDING FACTOR
  161.          BSR       FFPARND   ROUND APPROPRIATLEY
  162.          LEA       (SP),A0   SETUP PUT
  163.          LEA       23(A0),A1 ARGUMENTS
  164.          MOVE.B    #$08,IOSBLK+3 FORCE UNFORMATTED MODE TO INHIBIT CR
  165.          BSR       PUT       SEND OUT RESULT OF CONVERSION
  166.          CLR.B     IOSBLK+3  TURN UNFORMATTED MODE BACK OFF
  167.          LEA       24(SP),SP DELETE WORK AREA
  168.          MOVE.W    CCRSAVE,CCR RESTORE CCR FOR BRANCH DISPLAY
  169.          BSR       DISPCCR   DISPLAY ALL BRANCH CONDITIONS VALID
  170.          BRA       INPUT     BACK FOR MORE
  171.  
  172. * INVALID RESPONSE - TARGET THE CHARACTER IN ERROR (A0->)
  173. ERRORSYN MOVE.L    A6,SP     RESTORE STACK BACK TO NORMAL
  174.          SUB.L     SP,A0     FIND OFFSET TO BAD CHARACTER
  175.          MOVE.L    A0,D0     PAD WITH BLANKS
  176. LOOP2PD  MOVE.B    #' ',0(SP,D0) BLANK OUT FRONT END
  177.          DBRA      D0,LOOP2PD LOOP UNTIL DONE
  178.          MOVE.B    #'^',0(SP,A0) SET POINTER
  179.          MOVE.B    #$0D,1(SP,A0) SET END OF LINE
  180.          LEA       1(SP,A0),A1 END OF TEXT
  181.          MOVE.L    SP,A0     START OF TEXT
  182.          BSR       PUT       PLACE OUT FLAG
  183.          BSR       MSG       SEND MESSAGE
  184.          DC.L      'SYNTAX'
  185.          BRA       INPUT
  186.  
  187. * NEGATIVE SQUARE ROOT ERROR
  188. ERRORSQT MOVE.L    A6,SP     RESTORE STACK
  189.          BSR       MSG       SEND MSG
  190.          DC.L      'NEG SQRT'          EYE-CATCHER
  191.          BRA       CALPRNT   AND PRINT RESULT
  192.  
  193. * DIVIDE BY ZERO ERROR
  194. ERRORZDV MOVE.B    #1,ZDVSET SIGNAL DIVIDE BY ZERO DETECTED
  195.          RTR       AND CONTINUE WITH DIVIDE (OVERFLOW MODE)
  196.  
  197. * OVERFLOW ERROR
  198. ERRORV   MOVE.B    #1,OVFSET SIGNAL OVERFLOW DETECTED
  199.          RTR       AND CONTINUE WITH NEXT OPERATION
  200.  
  201.  
  202. ****************************
  203. * INTERPRET THE EXPRESSION *
  204. * OUTPUT - D7              *
  205. * IF ERRORS OCCUR WILL NOT *
  206. * RETURN TO CALLER         *
  207. ****************************
  208.  
  209. INTRP    CMP.B     #$0D,(A0)           ? NULL EXPRESSION
  210.          BEQ       ERRORSYN            ***SYNTAX ERROR***
  211.          BSR.S     EVAL                EVAULATE AS AN EXPRESSION
  212.          CMP.B     #$0D,(A0)           ? EXPRESSION END AT THE CR
  213.          BNE       ERRORSYN            ***SYNTAX ERROR***
  214.          RTS                           RETURN TO CALLER
  215.  
  216. ****************************
  217. * SUB EXPRESSION EVALUATOR *
  218. *       SUBROUTINE         *
  219. * OUTPUT: D7 - RESULT      *
  220. *  IF ERRORS WILL NOT      *
  221. *  RETURN TO CALLER.       *
  222. ****************************
  223. EVAL     BSR       TERM      OBTAIN FIRST TERM
  224. EVALNXT  MOVE.W    CCR,CCRSAVE SAVE LAST FUNCTION CCR STATUS
  225.          TRAPV               SET OVERFLOW HAD BIT
  226.          MOVE.L    D7,-(SP)  SAVE FIRST ARGUMENT ON STACK
  227. * TEST FOR DIADIC OPERATOR AND ONE MORE TERM
  228.          MOVE.B    (A0)+,D0  LOAD NEXT CHARACTER
  229.          CMP.B     #'+',D0    ? ADD
  230.          BNE.S     NOTADD    BRANCH IF NOT
  231. *  "+" ADD OPERATOR
  232.          BSR.S     TERM      GET NEXT TERM
  233.          TRAPV               CHECK OVERFLOW
  234.          MOVE.L    (SP)+,D6  RELOAD ARG1 FOR ARG2
  235.          JSR       FFPADD    ADD THEM
  236.          BRA.S     EVALNXT   TRY FOR ANOTHER TERM
  237. NOTADD   CMP.B     #'-',D0    ? SUBTRACT
  238.          BNE.S     NOTSUB    BRANCH IF NOT
  239. *  "-" SUBTRACT OPERATOR
  240.          BSR.S     TERM      GET NEXT TERM
  241.          TRAPV               CHECK OVERFLOW
  242.          MOVE.L    (SP)+,D6  RELOAD ARG1
  243.          EXG.L     D6,D7     MUST SWAP FOR CORRECT ORDER
  244.          JSR       FFPSUB    SUBTRACT THEM
  245.          BRA.S     EVALNXT   TRY FOR ANOTHER TERM
  246. NOTSUB   CMP.B     #'*',D0    ? MULTIPLY
  247.          BNE.S     NOTMULT   BRANCH IF NOT
  248.          CMP.B     #'*',(A0) ? POWER FUNCTION
  249.          BNE.S     ISMULT    BRANCH NO, IS MULTIPLY
  250. *  "**" POWER OPERATOR
  251.          ADD.L     #1,A0     STRIP OFF SECOND ASTERISK
  252.          BSR.S     TERM      GET NEXT TERM
  253.          TRAPV               CHECK OVERFLOW
  254.          MOVE.L    (SP)+,D6  RELOAD BASE VALUE
  255.          EXG.L     D6,D7     SWAP FOR FUNCTION CALL
  256.          JSR       FFPPWR    PERFORM POWER FUNCTION
  257.          BRA.S     EVALNXT   TRY ANOTHER ITEM
  258. *  "*" MULTIPLY OPERATOR
  259. ISMULT   BSR.S     TERM      GET NEXT TERM
  260.          TRAPV               CHECK OVERFLOW
  261.          MOVE.L    (SP)+,D6  RELOAD ARG1
  262.          JSR       FFPMUL    MULTIPLY THEM
  263.          BRA.S     EVALNXT   TRY ANOTHER TERM
  264. NOTMULT  CMP.B     #'/',D0    ? DIVIDE
  265.          BNE.S     NOTDIV    BRANCH IF NOT DIVIDE
  266. *  "/" DIVIDE OPERATOR
  267.          BSR.S     TERM      GET NEXT TERM
  268.          TRAPV               CHECK OVERFLOW
  269.          MOVE.L    (SP)+,D6  RELOAD ARG1
  270.          EXG.L     D6,D7     SWAP ARGS (ARG2 INTO ARG1)
  271.          JSR       FFPDIV    DIVIDE THEM
  272.          BRA       EVALNXT   TRY FOR ANOTHER TERM
  273. NOTDIV   CMP.B     #'?',D0   ? TEST FOR COMPARE OPERATOR
  274.          BNE.S     EXPRTN    RETURN IF NOT
  275. *  "?" COMPARISON OPERATOR
  276.          BSR.S     TERM      GET NEXT TERM
  277.          TRAPV               CHECK OVERFLOW
  278.          MOVE.L    (SP)+,D6  RESTORE FIRST ARGUMENT
  279.          JSR       FFPCMP    DO IEEE FORMAT COMPARISON
  280.          BSR       DISPCMP   DISPLAY CCR FOR COMPARISON
  281.          MOVE.L    A6,SP     RESTORE STACK TO TOP LEVEL
  282.          BRA       INPUT     AND PERFORM NEXT REQUEST
  283.  
  284. EXPRTN   SUB.L     #1,A0     BACK TO CURRENT POSITION
  285.          MOVE.L    (SP)+,D7  RESTORE UNUSED ARGUMENT
  286.          RTS                 RETURN TO CALLER
  287.  
  288.  
  289. *************************
  290. * OBTAIN A TERM (VALUE) *
  291. *  OUTPUT: D7 - VALUE   *
  292. *          V - OVERFLOW *
  293. * WILL NOT RETURN TO    *
  294. * CALLER IF ERROR       *
  295. *************************
  296. * SCAN FUNCTION TABLE FOR MATCH
  297. TERM     LEA       FNCTNTBL,A1 SETUP TABLE ADDRESS
  298.          MOVE.L    #NUMFUN,D1 COUNT TABLE ENTRIES
  299. FNCNXT   MOVE.W    (A1)+,D2  PREPARE COMPARE LENGTH
  300.          MOVE.L    A1,A2     PREPARE ENTRY STRING POINTER
  301.          MOVE.L    A0,A3     WITH INPUT SCAN STRING
  302. FNCMPR   CMP.B     (A2)+,(A3)+ ? STILL VALID MATCH
  303.          DBNE      D2,FNCMPR LOOP IF SO
  304.          BEQ.S     GOTFUNC   BRANCH FOR MATCH
  305.          LEA       12(A1),A1 TO NEXT ENTRY POSITION
  306.          DBRA      D1,FNCNXT LOOP IF MORE TO CHECK
  307.          BRA       NOTFUNC   BRANCH NOT A FUNCTION
  308.  
  309. GOTFUNC  MOVE.L    8(A1),-(SP) SAVE ENTRY POINT ADDRESS
  310.          MOVE.L    A3,A0     BUMP SCAN TO AFTER PAREN
  311.          BSR       EVAL      OBTAIN INSIDE EXPRESSION
  312.          MOVE.L    (SP)+,A1  LOAD FUNCTION ROUTINE ADDRESS
  313.          JSR       (A1)      CALL APPROPRIATE ROUTINE
  314.          SUBA.W   #2,A7      CLEAR SPOT FOR CCR
  315.          MOVEM.L  D0,-(SP)   PUSH D0 ON STACK
  316.          SF       D0         CLR.B D0 W/O CHANGING CCR
  317.          BNE.S    CCZ        CHECK Z BIT,BRANCH IF CLR
  318.          BSET     #6,D0      SET BIT 6 TO 1 FOR Z BIT
  319. CCZ      BCC.S    CCC        CHECK C BIT,BRANCH IF CLR
  320.          BSET     #4,D0      SET BIT 4 TO 1 FOR C BIT
  321. CCC      BVC.S    CCV        CHECK V BIT,BRANCH IF CLR
  322.          BSET     #5,D0      SET BIT 5 TO 1 FOR V BIT
  323. CCV      BPL.S    CCN        CHECK N BIT,BRANCH IF CLR
  324.          BSET     #7,D0      SET BIT 7 TO 1 FOR N BIT
  325. CCN      ROXR.B   #4,D0      ROTATE X BIT IN
  326.          AND.W    #$1F,D0    CLEAR UPPER BYTE
  327.          MOVE.W   D0,4(SP)   SAVE CCR OF RESULT ON THE STACK
  328.          MOVE.L   (SP)+,D0   RESTORE OLD D0 VALUE
  329.          CMP.B     #')',(A0)+  ARE THEY?
  330.          BNE       ERRORSYN  BRANCH SYNTAX ERROR IF NOT
  331.          RTR                 RETURN WITH CONDITION CODE
  332.  
  333. * FUNCTION TABLE
  334. FNCTNTBL DC.W      0                   VANILLA PARENTHESIS
  335.          DC.L      '(       ',FPAREN
  336.          DC.W      4                   SQUARE ROOT
  337.          DC.L      'SQRT(   ',FSQRT
  338.          DC.W      3                   SINE
  339.          DC.L      'SIN(    ',FFPSIN
  340.          DC.W      3                   COSINE
  341.          DC.L      'COS(    ',FFPCOS
  342.          DC.W      3                   TANGENT
  343.          DC.L      'TAN(    ',FFPTAN
  344.          DC.W      3                   EXPONENT
  345.          DC.L      'EXP(    ',FFPEXP
  346.          DC.W      3                   LOGORITHM
  347.          DC.L      'LOG(    ',FFPLOG
  348.          DC.W      4                   ARCTANGENT
  349.          DC.L      'ATAN(   ',FFPATAN
  350.          DC.W      4                   HYPERBOLIC SINE
  351.          DC.L      'SINH(   ',FFPSINH
  352.          DC.W      4                   HYPERBOLIC COSINE
  353.          DC.L      'COSH(   ',FFPCOSH
  354.          DC.W      4                   HYPERBOLIC TANGENT
  355.          DC.L      'TANH(   ',FFPTANH
  356.          DC.W      3                   TST
  357.          DC.L      'TST(    ',FFPTST
  358.          DC.W      3                   NEGATE
  359.          DC.L      'NEG(    ',FFPNEG
  360.          DC.W      3                   ABSOLUTE VALUE
  361.          DC.L      'ABS(    ',FFPABS
  362.          DC.W      3                   INTEGER
  363.          DC.L      'INT(    ',FINT
  364.  
  365. NUMFUN   EQU       (*-FNCTNTBL)/12
  366.  
  367. * PARENTHESIS EXPRESSION
  368. FPAREN   RTS       NO FUNCTION REQUIRED
  369.  
  370. * SQUARE ROOT CALL
  371. FSQRT    JSR       FFPSQRT   CALL SQUARE ROOT
  372.          BVS       ERRORSQT  BRANCH IF NEGATIVE ARGUMENT ATTEMPTED
  373.          RTS                 RETURN TO CALLER
  374.  
  375. * INTEGER FUNCTION
  376. FINT     MOVE.L    D7,-(SP)  SAVE ORIGINAL ARGUMENT IN CASE OF OVERFLOW
  377.          JSR       FFPFPI    CONVERT TO INTEGER
  378.          BVC.S     FINTOK    BRANCH IF NO OVERFLOW DETECTED
  379. * OVERFLOW - RETURN ORIGINAL ARGUMENT SINCE HAS NO FRACTION ANYWAY
  380.          MOVE.L    (SP)+,D7  RETURN ORIGINAL ARGUMENT
  381.          TST.B     D7        SET CCR PROPERLY
  382.          RTS                 RETURN TO CALLER
  383. * NO OVERFLOW - CONVERT BACK
  384. FINTOK   JSR       FFPIFP    BACK TO FLOAT
  385.          ADD.L     #4,SP     DELETE SAVED ARGUMENT FROM STACK
  386.          RTS                 AND RETURN
  387.  
  388. * TEST FOR VARIABLES OR INFIX + AND -
  389. NOTFUNC  MOVE.B    (A0)+,D0  LOAD NEXT CHARACTER
  390.          MOVE.L    X,D7      DEFAULT TO X
  391.          CMP.B     #'X',D0   IS IT?
  392.          BEQ.S     TERMRTN   RETURN IF SO
  393.          MOVE.L    Y,D7      DEFAULT TO Y
  394.          CMP.B     #'Y',D0   ? IS IT
  395.          BEQ.S     TERMRTN   RETURN IF SO
  396.          CMP.B     #'+',D0    TEST PLUS
  397.          BEQ       NOTFUNC   BR YES TO SKIP IT
  398.          CMP.B     #'-',D0    INFIX MINUS
  399.          BNE.S     NOTMINUS  NO, TRY SOMTHING ELSE
  400. * IF THIS IS A NEGATIVE ASCII VALUE, WE MUST LET IT BE CONVERTED SINCE
  401. * A POSITIVE VALUE HAS LESS RANGE THAN A NEGATIVE ONE
  402.          CMP.B     #'.',(A0)  ? NUMERIC ASCII FOLLOWS
  403.          BEQ.S     NOTMINUS  YES, LET CONVERSION HANDLE IT PROPERLY
  404.          CMP.B     #'0',(A0)  ? ASCII NUMBER
  405.          BLS.S     DONEG     NOPE, COMPLEMENT THE FOLLOWING VALUE
  406.          CMP.B     #'9',(A0)  ? ASCII NUMBER
  407.          BLS.S     NOTMINUS   YEP, ALLOW PROPER CONVERSION
  408. DONEG    BSR       TERM      OBTAIN TERM
  409.          JSR       FFPNEG    NEGATE THE RESULT
  410. TERMRTN  RTS                 RETURN TO CALLER
  411.  
  412. * CHECK FOR DIRECT HEXADECIMAL SPECIFICATION
  413. NOTMINUS CMP.B     #'$',D0   ? HEXADECIMAL HERE
  414.          BNE.S     NOTHEX    BRANCH IF NOT
  415.          CLR.L     D7        START BUILDING THE VALUE
  416. PRSHEX   MOVE.B    (A0),D0   LOAD NEXT CHARACTER
  417.          CMP.B     #'0',D0   ? LESS THAN ASCII ZERO
  418.          BCS.S     TERMRTN   RETURN WITH RESULT IN D7 IF SO
  419.          CMP.B     #'9',D0   ? GREATER THAN NINE
  420.          BLS.S     GOTHEX    BRANCH NOT, IS A VALID DECIMAL DIGIT
  421.          CMP.B     #'A',D0   ? LESS THAN ASCII "A"
  422.          BCS.S     TERMRTN   RETURN RESULT IF NOT HEX DIGIT
  423.          CMP.B     #'F',D0   ? GREATER THAN "F"
  424.          BHI.S     TERMRTN   RETURN RESULT IF NOT HEX DIGIT
  425.          ADD.B     #9,D0     RE-MAP INTO BINARY RANGE
  426. GOTHEX   ADD.L     #1,A0     BUMP PAST THIS CHARACTER
  427.          AND.B     #$F,D0    ISOLATE HEX DIGIT
  428.          CMP.L     #$0FFFFFFF,D7 ? WILL ANOTHER DIGIT OVERFLOW
  429.          BHI       ERRORSYN  YES, BRANCH FOR SYNTAX ERROR
  430.          LSL.L     #4,D7     SHIFT OVER SAFELY FOR NEXT DIGIT
  431.          OR.B      D0,D7     OR NEW DIGIT IN LOW BYTE
  432.          BRA.S     PRSHEX    GO PARSE ANOTHER HEX DIGIT
  433.  
  434.  
  435. * ATTEMPT TO TREAT IT AS AN ASCII NUMBER
  436. NOTHEX   SUB.L     #1,A0     ATTEMPT ASCII INPUT VALUE
  437.          JSR       FFPAFP    ATTEMPT ASCII TO FLOAT
  438.          BCS       ERRORSYN  SYNTAX ERROR IF NO GOOD
  439.          RTS                 RETURN IF GOT VALUE
  440.  
  441. ************
  442. * END TEST *
  443. ************
  444. QUIT     BSR.S     MSG       ISSUE DONE MESSAGE
  445.          DC.L      '  DONE'
  446.          MOVE.L    #15,D0    TERMINATE TASK
  447.          TRAP      #1        HERE
  448.  
  449.  
  450. *   *
  451. *   * DISPLAY THE CCR BRANCH CONDITIONS SUBROUTINE
  452. *   *   EVERYTHING TRANSPARENT (INCLUDING CCR)
  453. *   *
  454.  
  455. DISPCMP  MOVEM.L   D0-D1/A0-A1,-(SP) SAVE WORK REGISTERS ON THE STACK
  456.          MOVE.W    CCR,D0     SAVE CONDITION CODE REGISTER FOR TESTS
  457.          MOVE.L    SP,A1     STACK FRAME POINTER
  458.          MOVE.W    #'GT',-(SP)  DEFAULT CONDITION
  459.          MOVE.W    D0,CCR    RESET CCR
  460.          BGT.S     DISPGT    BRANCH CORRECT
  461.          MOVE.W    #'LE',(SP) CHANGE
  462. DISPGT   MOVE.L    #'GE  ',-(SP)  DEFAULT CONDITION
  463.          MOVE.W    D0,CCR    RESET CCR
  464.          BGE.S     DISPPL    BRANCH CORRECT
  465.          MOVE.W    #'LT',(SP) CHANGE
  466.          BRA.S     DISPPL    ENTER COMMON CODE
  467.  
  468. * REGULAR DISPLAY
  469. DISPCCR  MOVEM.L   D0-D1/A0-A1,-(SP) SAVE WORK REGISTERS ON THE STACK
  470.          MOVE.W    CCR,D0     SAVE CONDITION CODE REGISTER FOR TESTS
  471.          MOVE.L    SP,A1     STACK FRAME POINTER
  472. * TEST FOR OVERFLOW (V SET)
  473.          BVC.S     NOTVS     BRANCH NOT OVERFLOW
  474.          MOVE.L    #'FLOW',-(SP) SETUP OVERFLOW EYE-CATCHER
  475.          MOVE.L    #'OVER',-(SP) DITTO
  476. * SETUP ARITHMETIC COMPARISONS
  477. NOTVS    MOVE.L    #'PL  ',-(SP)  DEFAULT CONDITION
  478.          MOVE.W    D0,CCR    RESET CCR
  479.          BPL.S     DISPPL    BRANCH CORRECT
  480.          MOVE.W    #'MI',(SP) CHANGE
  481. DISPPL   MOVE.L    #'EQ  ',-(SP)  DEFAULT CONDITION
  482.          MOVE.W    D0,CCR    RESET CCR
  483.          BEQ.S     DISPEQ    BRANCH CORRECT
  484.          MOVE.W    #'NE',(SP) CHANGE
  485. DISPEQ   MOVE.L    #'    ',-(SP) ADD BLANKS TO BEGINNING
  486.          MOVE.L    SP,A0     START OF STRING PRINT
  487.          SUB.L     #1,A1     POINT TO LAST CHARACTER
  488.          BSR.S     PUT       SEND STRING TO CONSOLE
  489.          LEA       1(A1),SP  RESTORE STACK BACK
  490.          MOVE.W    D0,CCR  RESTORE CCR
  491.          MOVEM.L   (SP)+,D0-D1/A0-A1 RESTORE REGISTERS
  492.          RTS                 RETURN TO CALLER
  493.  
  494. *   *
  495. *   * MSG SUBROUTINE
  496. *   *  INPUT: (SP) POINT TO EIGHT BYTE TEXT FOLLOWING BSR/JSR
  497. *   *
  498. MSG      MOVEM.L   D0/A0/A1,-(SP) SAVE REGS
  499.          MOVE.L    3*4(SP),A0 LOAD RETURN POINTER
  500.          LEA       7(A0),A1   POINT TO BUFFER END
  501.          BSR.S     PUT       ISSUE IOS CALL
  502.          MOVEM.L   (SP)+,D0/A0/A1 RELOAD REGISTERS
  503.          ADD.L     #8,(SP)   ADJUST RETURN ADDRESS
  504.          RTS                 RETURN TO CALLER
  505.  
  506. *   *
  507. *   * PUT SUBROUTINE
  508. *   *  INPUT: A0->TEXT START, A1->TEXT END
  509. *   *
  510. PUT      MOVEM.L   D0/A0/A1,-(SP) SAVE REGS
  511.          MOVEM.L   A0-A1,BUFPTR SETUP BUFFER POINTERS
  512.          SUB.L     A0,A1     COMPUTE LENGTH-1
  513.          LEA       1(A1),A1  ADD ONE
  514.          MOVE.L    A1,BUFLEN INSERT LENGTH
  515.          MOVE.B    #6,DEVICE TO OUTPUT STREAM
  516.          MOVE.B    #2,IOSBLK+1 AND WRITE FUNCTION
  517.          LEA       IOSBLK,A0  LOAD BLOCK ADDRESS
  518.          TRAP      #2        ISSUE IOS CALL
  519.          MOVEM.L   (SP)+,D0/A0/A1 RELOAD REGISTERS
  520.          RTS                 RETURN TO CALLER
  521.  
  522. *   *
  523. *   * GET SUBROUTINE
  524. *   *   INPUT: A0->BUFFER START, A1->LAST OF BUFFER
  525. *   *
  526. GET      MOVEM.L   D0/A0/A1,-(SP) SAVE REGS
  527.          MOVEM.L   A0-A1,BUFPTR PLACE BUFFER POINTERS
  528.          MOVE.B    #1,IOSBLK+1 PERFORM READ
  529.          MOVE.B    #5,DEVICE READ FROM INPUT DEVICE
  530.          LEA       IOSBLK,A0 LOAD PARAMETER
  531.          TRAP      #2        IOS CALL
  532.          MOVEM.L   (SP)+,D0/A0/A1 RESTORE REGISTERS
  533.          RTS                 RETURN TO CALLER
  534.  
  535. * IOS BLOCK FOR TERMINAL FORMATED SEND
  536. IOSBLK   DC.B     0,2,0,0    WRITE FORMATTED WAIT
  537.          DC.B     0
  538. DEVICE   DC.B     0,0,0
  539.          DC.L     0
  540. BUFPTR   DC.L      0,0
  541. BUFLEN   DC.L      0,0
  542.  
  543. * VARIABLES
  544. X        DC.L      0
  545. Y        DC.L      0
  546. CCRSAVE  DC.W      0
  547. ROUND    DC.L      -100      ROUNDING FACTOR
  548.  
  549. * OVERFLOW FLAGS
  550. OVFSET   DC.B      0         OVERFLOW RETURNED FLAG
  551. ZDVSET   DC.B      0         ZERO DIVIDE SET
  552.  
  553. * EXCEPTION VECTOR SUBSTITUTION
  554. EXCTBL   DC.L      0,0,0,ERRORZDV,0,ERRORV,0,0,0
  555.  
  556. * STARTUP MESSAGE
  557. STARTM   DC.W      '  FAST FLOATING POINT CALCULATOR'
  558. STARTME  DC.W     0
  559. STARTM2  DC.W      '(C) COPYRIGHT 1980 BY MOTOROLA INC.'
  560. STARTM2E DC.W      0
  561.  
  562. * PROGRAM STACK
  563.          DCB.W     100,0      STACK AREA
  564. STACK    EQU       *
  565.  
  566.          END       FFPCALC
  567.  
  568.